{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04-transfer-learning-in-tensorflow-part-1-feature-extraction-video.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMmxupqY3JJ7TXf3nZHGoUq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mrdbourke/tensorflow-deep-learning/blob/main/video_notebooks/04_transfer_learning_in_tensorflow_part_1_feature_extraction_video.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1r8Bt5EdzVo"
      },
      "source": [
        "# Transfer Learning with TensorFlow Part 1: Feature Extraction\n",
        "\n",
        "Transfer learning is leveraging a working model's existing architecture and learned patterns for our own problem.\n",
        "\n",
        "There are two main benefits:\n",
        "1. Can leverage an existing neural network architecture proven to work on problems similar to our own.\n",
        "2. Can leverage a working neural network architecture which has already learned patterns on similar data to our own, then we can adapt those patterns to our own data\n",
        "\n",
        "See full course materials on GitHub: https://github.com/mrdbourke/tensorflow-deep-learning/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sAfDnA31eZcu",
        "outputId": "c893c4db-4426-4111-fa4f-6dbd0e544909"
      },
      "source": [
        "# Are we using a GPU?\n",
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mon Feb 15 01:10:58 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 460.39       Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   37C    P8     9W /  70W |      0MiB / 15109MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DxTYvBFVentG"
      },
      "source": [
        "## Downloading and becoming one with the data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cGeh8hWlesPd",
        "outputId": "095b07e8-09e0-4c9a-9037-305ddf660e0c"
      },
      "source": [
        "# Get data (10% of 10 food classes from Food101) - https://www.kaggle.com/dansbecker/food-101 \n",
        "import zipfile\n",
        "\n",
        "# Download the data\n",
        "!wget https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
        "\n",
        "# Unzip the downloaded file\n",
        "zip_ref = zipfile.ZipFile(\"10_food_classes_10_percent.zip\")\n",
        "zip_ref.extractall()\n",
        "zip_ref.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2021-02-15 01:10:59--  https://storage.googleapis.com/ztm_tf_course/food_vision/10_food_classes_10_percent.zip\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.8.16, 172.217.13.80, 172.217.13.240, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.8.16|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 168546183 (161M) [application/zip]\n",
            "Saving to: ‘10_food_classes_10_percent.zip’\n",
            "\n",
            "10_food_classes_10_ 100%[===================>] 160.74M  59.6MB/s    in 2.7s    \n",
            "\n",
            "2021-02-15 01:11:02 (59.6 MB/s) - ‘10_food_classes_10_percent.zip’ saved [168546183/168546183]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jflo1HBrfEue",
        "outputId": "8db396ea-3d2f-4498-9091-80a3a9e1b5cd"
      },
      "source": [
        "# How many images in each folder?\n",
        "import os\n",
        "\n",
        "# Walk through 10 percent data directory and list number of files\n",
        "for dirpath, dirnames, filenames in os.walk(\"10_food_classes_10_percent\"):\n",
        "  print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are 2 directories and 0 images in '10_food_classes_10_percent'.\n",
            "There are 10 directories and 0 images in '10_food_classes_10_percent/train'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ice_cream'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/ramen'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_wings'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/pizza'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/steak'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/fried_rice'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/hamburger'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/grilled_salmon'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/sushi'.\n",
            "There are 0 directories and 75 images in '10_food_classes_10_percent/train/chicken_curry'.\n",
            "There are 10 directories and 0 images in '10_food_classes_10_percent/test'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ice_cream'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/ramen'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_wings'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/pizza'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/steak'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/fried_rice'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/hamburger'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/grilled_salmon'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/sushi'.\n",
            "There are 0 directories and 250 images in '10_food_classes_10_percent/test/chicken_curry'.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P893f1c7fhmX"
      },
      "source": [
        "## Creating data loaders (preparing the data)\n",
        "\n",
        "We'll use the `ImageDataGenerator` class to load in our images in batches."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W5eHlXS3f_CV",
        "outputId": "fbf74a24-07d0-41c0-f6b1-196125e83892"
      },
      "source": [
        "# Setup data inputs\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "IMAGE_SHAPE = (224, 224)\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "train_dir = \"10_food_classes_10_percent/train/\"\n",
        "test_dir = \"10_food_classes_10_percent/test/\"\n",
        "\n",
        "train_datagen = ImageDataGenerator(rescale=1/255.)\n",
        "test_datagen = ImageDataGenerator(rescale=1/255.)\n",
        "\n",
        "print(\"Training images:\")\n",
        "train_data_10_percent = train_datagen.flow_from_directory(train_dir, \n",
        "                                                          target_size=IMAGE_SHAPE,\n",
        "                                                          batch_size=BATCH_SIZE,\n",
        "                                                          class_mode=\"categorical\")\n",
        "\n",
        "print(\"Testing images:\")\n",
        "test_data = test_datagen.flow_from_directory(test_dir,\n",
        "                                             target_size=IMAGE_SHAPE,\n",
        "                                             batch_size=BATCH_SIZE,\n",
        "                                             class_mode=\"categorical\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Training images:\n",
            "Found 750 images belonging to 10 classes.\n",
            "Testing images:\n",
            "Found 2500 images belonging to 10 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NhOBoTQNg2Gg"
      },
      "source": [
        "## Setting up callbacks (things to run whilst our model trains)\n",
        "\n",
        "Callbacks are extra functionality you can add to your models to be performed during or after training. Some of the most popular callbacks:\n",
        "\n",
        "* Tracking experiments with the TensorBoard callback\n",
        "* Model checkpoint with the ModelCheckpoint callback\n",
        "* Stopping a model from training (before it trains too long and overfits) with the EarlyStopping callback"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ViytMClih4C"
      },
      "source": [
        "# Create TensorBoard callback (functionized beause we need to create a new one for each model)\n",
        "import datetime\n",
        "\n",
        "def create_tensorboard_callback(dir_name, experiment_name):\n",
        "  log_dir = dir_name + \"/\" + experiment_name + \"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "  tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)\n",
        "  print(f\"Saving TensorBoard log files to: {log_dir}\")\n",
        "  return tensorboard_callback"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WjuTDU6Qk4-b"
      },
      "source": [
        "> 🔑 **Note:** You can customize the directory where your TensorBoard logs (model training metrics) get saved to whatever you like. The `log_dir` parameter we've created above is only one option."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vwVPObfRkRlQ"
      },
      "source": [
        "## Creating models using TensorFlow Hub\n",
        "\n",
        "In the past we've used TensorFlow to create our own models layer by layer from scratch.\n",
        "\n",
        "Now we're going to do a similar process, except the majroity of our model's layers are going to come from TensorFlow Hub.\n",
        "\n",
        "We can access pretrained models on: https://tfhub.dev/\n",
        "\n",
        "Browsing the TensorFlow Hub page and sorting for image classification, we found the following feature vector model link: https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DpffmlOGmkmF"
      },
      "source": [
        "# Let's compare the following two models\n",
        "resnet_url = \"https://tfhub.dev/google/imagenet/resnet_v2_50/feature_vector/4\"\n",
        "\n",
        "efficientnet_url = \"https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xjRXzDNcqJZa"
      },
      "source": [
        "# Import dependencies \n",
        "import tensorflow as tf\n",
        "import tensorflow_hub as hub\n",
        "from tensorflow.keras import layers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3dnz5Mgsrw9M",
        "outputId": "d918f3d4-0d98-43c3-b477-b4ac411e4dd5"
      },
      "source": [
        "IMAGE_SHAPE + (3,)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(224, 224, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0P-l1B8Uqh3G"
      },
      "source": [
        "# Let's make a create_model() function to create a model from a URL\n",
        "def create_model(model_url, num_classes=10):\n",
        "  \"\"\"\n",
        "  Takes a TensorFlow Hub URL and creates a Keras Sequential model with it.\n",
        "\n",
        "  Args:\n",
        "    model_url (str): A TensorFlow Hub feature extraction URL.\n",
        "    num_classes (int): Number of output neurons in the output layer,\n",
        "      should be equal to number of target classes, default 10.\n",
        "  \n",
        "  Returns:\n",
        "    An uncompiled Keras Sequential model with model_url as feature extractor\n",
        "    layer and Dense output layer with num_classes output neurons.\n",
        "  \"\"\"\n",
        "  # Download the pretrained model and save it as a Keras layer\n",
        "  feature_extractor_layer = hub.KerasLayer(model_url,\n",
        "                                           trainable=False, # freeze the already learned patterns\n",
        "                                           name=\"feature_extraction_lyaer\",\n",
        "                                           input_shape=IMAGE_SHAPE+(3,)) \n",
        "\n",
        "  # Create our own model\n",
        "  model = tf.keras.Sequential([\n",
        "    feature_extractor_layer,\n",
        "    layers.Dense(num_classes, activation=\"softmax\", name=\"output_layer\")\n",
        "  ])\n",
        "    \n",
        "  return model  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7g46khFsKTj"
      },
      "source": [
        "### Creating and testing ResNet TensorFlow Hub Feature Extraction model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hSY8MtJsDJ8"
      },
      "source": [
        "# Create Resnet model \n",
        "resnet_model = create_model(resnet_url,\n",
        "                            num_classes=train_data_10_percent.num_classes)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bq3C1VDosxw6"
      },
      "source": [
        "# Compile our resnet model\n",
        "resnet_model.compile(loss=\"categorical_crossentropy\",\n",
        "                     optimizer=tf.keras.optimizers.Adam(),\n",
        "                     metrics=[\"accuracy\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bXOYieb2salv",
        "outputId": "7a01fb4b-efd7-49c6-97ee-c40f884d9234"
      },
      "source": [
        "# Let's fit our ResNet model to the data (10 percent of 10 classes)\n",
        "resnet_history = resnet_model.fit(train_data_10_percent,\n",
        "                                  epochs=5,\n",
        "                                  steps_per_epoch=len(train_data_10_percent),\n",
        "                                  validation_data=test_data,\n",
        "                                  validation_steps=len(test_data),\n",
        "                                  callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\",\n",
        "                                                                         experiment_name=\"resnet50V2\"\n",
        "                                                                         )])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/resnet50V2/20210215-011114\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 27s 753ms/step - loss: 2.5768 - accuracy: 0.1669 - val_loss: 1.3738 - val_accuracy: 0.5660\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 16s 672ms/step - loss: 1.0721 - accuracy: 0.6647 - val_loss: 0.9163 - val_accuracy: 0.7100\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 16s 668ms/step - loss: 0.6938 - accuracy: 0.8048 - val_loss: 0.7782 - val_accuracy: 0.7520\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 16s 667ms/step - loss: 0.5048 - accuracy: 0.8679 - val_loss: 0.7416 - val_accuracy: 0.7436\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 16s 667ms/step - loss: 0.4115 - accuracy: 0.9072 - val_loss: 0.7071 - val_accuracy: 0.7580\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5vW0JCXPwder"
      },
      "source": [
        "Wow!\n",
        "\n",
        "That. Is. Incredible. Our transfer learning feature extractor model out performed ALL of the previous models we built by hand... (substantially) and in a quicker training time AND with only 10% of the training examples."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VuUcHxspvbre"
      },
      "source": [
        "# Let's create a function to plot our loss curves...\n",
        "# Tidbit: you could put a function like this into a script called \"helper.py\" and import it when you need it...\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot the validation and training curves\n",
        "def plot_loss_curves(history):\n",
        "  \"\"\"\n",
        "  Returns separate loss curves for training and validation metrics.\n",
        "\n",
        "  Args:\n",
        "    history: TensorFlow History object.\n",
        "\n",
        "  Returns:\n",
        "    Plots of training/validation loss and accuracy metrics.\n",
        "  \"\"\"\n",
        "  loss = history.history[\"loss\"]\n",
        "  val_loss = history.history[\"val_loss\"]\n",
        "\n",
        "  accuracy = history.history[\"accuracy\"]\n",
        "  val_accuracy = history.history[\"val_accuracy\"]\n",
        "\n",
        "  epochs = range(len(history.history[\"loss\"]))\n",
        "\n",
        "  # Plot loss\n",
        "  plt.plot(epochs, loss, label=\"training_loss\")\n",
        "  plt.plot(epochs, val_loss, label=\"val_loss\")\n",
        "  plt.title(\"Loss\")\n",
        "  plt.xlabel(\"Epochs\")\n",
        "  plt.legend()\n",
        "\n",
        "  # Plot accuracy\n",
        "  plt.figure()\n",
        "  plt.plot(epochs, accuracy, label=\"training_accuracy\")\n",
        "  plt.plot(epochs, val_accuracy, label=\"val_accuracy\")\n",
        "  plt.title(\"Accuracy\")\n",
        "  plt.xlabel(\"Epochs\")\n",
        "  plt.legend();\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "mUuUM09tzMHc",
        "outputId": "df7d8cd3-0043-48e3-faef-d99f0ee308d6"
      },
      "source": [
        "plot_loss_curves(resnet_history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qddtb8zIzjn3"
      },
      "source": [
        "### Creating and testing EfficientNetB0 TensorFlow Hub Feature Extraction model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CsME3MLezOJw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "27ee0a78-bfee-472f-8c29-c47204eda422"
      },
      "source": [
        "# Create EfficinetNetB0 feature extractor model - details on EfficientNet: https://ai.googleblog.com/2019/05/efficientnet-improving-accuracy-and.html#:~:text=EfficientNet%2DB0%20is%20the%20baseline,than%20the%20best%20existing%20CNN.\n",
        "efficientnet_model = create_model(model_url=efficientnet_url,\n",
        "                                  num_classes=train_data_10_percent.num_classes)\n",
        "\n",
        "# Compile EfficientNet model\n",
        "efficientnet_model.compile(loss=\"categorical_crossentropy\",\n",
        "                           optimizer=tf.keras.optimizers.Adam(),\n",
        "                           metrics=[\"accuracy\"])\n",
        "\n",
        "# Fit EfficientNet model to 10% of training data\n",
        "efficientnet_history = efficientnet_model.fit(train_data_10_percent,\n",
        "                                              epochs=5,\n",
        "                                              steps_per_epoch=len(train_data_10_percent),\n",
        "                                              validation_data=test_data,\n",
        "                                              validation_steps=len(test_data),\n",
        "                                              callbacks=[create_tensorboard_callback(dir_name=\"tensorflow_hub\",\n",
        "                                                                                     experiment_name=\"efficientnetb0\")])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Saving TensorBoard log files to: tensorflow_hub/efficientnetb0/20210215-014456\n",
            "Epoch 1/5\n",
            "24/24 [==============================] - 24s 742ms/step - loss: 1.9990 - accuracy: 0.3260 - val_loss: 1.2458 - val_accuracy: 0.7532\n",
            "Epoch 2/5\n",
            "24/24 [==============================] - 15s 633ms/step - loss: 1.1410 - accuracy: 0.7557 - val_loss: 0.8425 - val_accuracy: 0.8236\n",
            "Epoch 3/5\n",
            "24/24 [==============================] - 15s 633ms/step - loss: 0.7825 - accuracy: 0.8237 - val_loss: 0.6847 - val_accuracy: 0.8460\n",
            "Epoch 4/5\n",
            "24/24 [==============================] - 15s 630ms/step - loss: 0.5854 - accuracy: 0.8776 - val_loss: 0.6021 - val_accuracy: 0.8564\n",
            "Epoch 5/5\n",
            "24/24 [==============================] - 15s 632ms/step - loss: 0.5164 - accuracy: 0.9064 - val_loss: 0.5499 - val_accuracy: 0.8668\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "id": "r68y4yvYXIxh",
        "outputId": "36e10f1a-9859-4d1d-dc10-e909a390812a"
      },
      "source": [
        "plot_loss_curves(efficientnet_history)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "neXMTbhgX43z",
        "outputId": "a3406d3e-e96c-4e76-9746-118bf73c1c33"
      },
      "source": [
        "efficientnet_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "feature_extraction_lyaer (Ke (None, 1280)              4049564   \n",
            "_________________________________________________________________\n",
            "output_layer (Dense)         (None, 10)                12810     \n",
            "=================================================================\n",
            "Total params: 4,062,374\n",
            "Trainable params: 12,810\n",
            "Non-trainable params: 4,049,564\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SDI9TmY7Yp1_",
        "outputId": "0557f280-87f3-4074-c2bb-e5c982123fd1"
      },
      "source": [
        "resnet_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "feature_extraction_lyaer (Ke (None, 2048)              23564800  \n",
            "_________________________________________________________________\n",
            "output_layer (Dense)         (None, 10)                20490     \n",
            "=================================================================\n",
            "Total params: 23,585,290\n",
            "Trainable params: 20,490\n",
            "Non-trainable params: 23,564,800\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1OyOGF1DZxkQ",
        "outputId": "7b0d39d5-546e-4561-b1b4-c8a0b84501e1"
      },
      "source": [
        "# How many layers does our efficientnetb0 feature extractor have?\n",
        "len(efficientnet_model.layers[0].weights)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "309"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20CVkEoCY0r5"
      },
      "source": [
        "## Different types of transfer learning\n",
        "\n",
        "* **\"As is\" transfer learning** - using an existing model with no changes what so ever (e.g using ImageNet model on 1000 ImageNet classes, none of your own)\n",
        "* **\"Feature extraction\"** transfer learning - use the prelearned patterns of an existing model (e.g. EfficientNetB0 trained on ImageNet) and adjust the output layer for your own problem (e.g. 1000 classes -> 10 classes of food)\n",
        "* **\"Fine-tuning\" transfer learning** - use the prelearned patterns of an existing model and \"fine-tune\" many or all of the underlying layers (including new output layers)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4_yoziIzZpYe"
      },
      "source": [
        "## Comparing our models results using TensorBoard\n",
        "\n",
        "> 🔑 **Note:** When you upload things to [TensorBoard.dev](https://tensorboard.dev/), you experiments are public. So if you're running private experiments (things you don't want others to see) do not upload them to TensorBoard.dev."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dMNEfYfbbQsF"
      },
      "source": [
        "# Upload TensorBoard dev records\n",
        "!tensorboard dev upload --logdir ./tensorflow_hub/ \\\n",
        "  --name \"EfficientNetB0 vs. ResNet50V2\" \\\n",
        "  --description \"Comparing two different TF Hub feature extraction model architectures using 10% of the training data\" \\\n",
        "  --one_shot"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YFq9QiEudZr2"
      },
      "source": [
        "Our TensorBoard experiments are uploaded publically here: https://tensorboard.dev/experiment/dQBrpdwIRgS2qI0Andv8Yg/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4GapERDkd242",
        "outputId": "b3d706da-ece9-460f-a6d0-90d2f30f6115"
      },
      "source": [
        "# Check out what TensorBoard experiments you have\n",
        "!tensorboard dev list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2021-02-15 02:17:31.857592: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
            "https://tensorboard.dev/experiment/dQBrpdwIRgS2qI0Andv8Yg/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction model architectures using 10% of the training data\n",
            "\tId                   dQBrpdwIRgS2qI0Andv8Yg\n",
            "\tCreated              2021-02-15 02:13:39 (3 minutes ago)\n",
            "\tUpdated              2021-02-15 02:13:41 (3 minutes ago)\n",
            "\tRuns                 4\n",
            "\tTags                 3\n",
            "\tScalars              40\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  6020432\n",
            "https://tensorboard.dev/experiment/OAE6KXizQZKQxDiqI3cnUQ/\n",
            "\tName                 Fine-tuning EfficientNetB0 on all Food101 Data\n",
            "\tDescription          Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001\n",
            "\tId                   OAE6KXizQZKQxDiqI3cnUQ\n",
            "\tCreated              2020-09-28 05:46:53\n",
            "\tUpdated              2020-09-28 05:46:55\n",
            "\tRuns                 2\n",
            "\tTags                 3\n",
            "\tScalars              56\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  1338330\n",
            "https://tensorboard.dev/experiment/2O76kw3PQbKl0lByfg5B4w/\n",
            "\tName                 Transfer learning experiments\n",
            "\tDescription          A series of different transfer learning experiments with varying amounts of data and fine-tuning\n",
            "\tId                   2O76kw3PQbKl0lByfg5B4w\n",
            "\tCreated              2020-09-17 22:51:37\n",
            "\tUpdated              2020-09-17 22:51:47\n",
            "\tRuns                 10\n",
            "\tTags                 3\n",
            "\tScalars              128\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  9520961\n",
            "https://tensorboard.dev/experiment/73taSKxXQeGPQsNBcVvY3g/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction models architectures using 10% of training images\n",
            "\tId                   73taSKxXQeGPQsNBcVvY3g\n",
            "\tCreated              2020-09-14 05:02:48\n",
            "\tUpdated              2020-09-14 05:02:50\n",
            "\tRuns                 4\n",
            "\tTags                 3\n",
            "\tScalars              40\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  3402042\n",
            "Total: 4 experiment(s)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xxx119bPen_0"
      },
      "source": [
        "# Delete an experiment\n",
        "# !tensorboard dev delete --experiment_id dQBrpdwIRgS2qI0Andv8Yg"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pcOzwcYke8K9",
        "outputId": "6fc304ec-972b-46c0-bbbc-ae8f2b46f060"
      },
      "source": [
        "# Confirm the deletion by re-checking what experiments you have left\n",
        "!tensorboard dev list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2021-02-15 02:19:14.889146: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.10.1\n",
            "https://tensorboard.dev/experiment/dQBrpdwIRgS2qI0Andv8Yg/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction model architectures using 10% of the training data\n",
            "\tId                   dQBrpdwIRgS2qI0Andv8Yg\n",
            "\tCreated              2021-02-15 02:13:39 (5 minutes ago)\n",
            "\tUpdated              2021-02-15 02:13:41 (5 minutes ago)\n",
            "\tRuns                 4\n",
            "\tTags                 3\n",
            "\tScalars              40\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  6020432\n",
            "https://tensorboard.dev/experiment/OAE6KXizQZKQxDiqI3cnUQ/\n",
            "\tName                 Fine-tuning EfficientNetB0 on all Food101 Data\n",
            "\tDescription          Training results for fine-tuning EfficientNetB0 on Food101 Data with learning rate 0.0001\n",
            "\tId                   OAE6KXizQZKQxDiqI3cnUQ\n",
            "\tCreated              2020-09-28 05:46:53\n",
            "\tUpdated              2020-09-28 05:46:55\n",
            "\tRuns                 2\n",
            "\tTags                 3\n",
            "\tScalars              56\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  1338330\n",
            "https://tensorboard.dev/experiment/2O76kw3PQbKl0lByfg5B4w/\n",
            "\tName                 Transfer learning experiments\n",
            "\tDescription          A series of different transfer learning experiments with varying amounts of data and fine-tuning\n",
            "\tId                   2O76kw3PQbKl0lByfg5B4w\n",
            "\tCreated              2020-09-17 22:51:37\n",
            "\tUpdated              2020-09-17 22:51:47\n",
            "\tRuns                 10\n",
            "\tTags                 3\n",
            "\tScalars              128\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  9520961\n",
            "https://tensorboard.dev/experiment/73taSKxXQeGPQsNBcVvY3g/\n",
            "\tName                 EfficientNetB0 vs. ResNet50V2\n",
            "\tDescription          Comparing two different TF Hub feature extraction models architectures using 10% of training images\n",
            "\tId                   73taSKxXQeGPQsNBcVvY3g\n",
            "\tCreated              2020-09-14 05:02:48\n",
            "\tUpdated              2020-09-14 05:02:50\n",
            "\tRuns                 4\n",
            "\tTags                 3\n",
            "\tScalars              40\n",
            "\tTensor bytes         0\n",
            "\tBinary object bytes  3402042\n",
            "Total: 4 experiment(s)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K9zom6GJfBGb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}